package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:31 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceServerDAOQueryBean extends BaseQueryBean {

  public WorkspaceServerDAOQueryBean() {
    super();
  }

  public WorkspaceServerDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceServerDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.Id, "id");
    }
  }

  public void addWorkspaceIdSelectProperty() {
    addWorkspaceIdSelectProperty("workspaceId");
  }

  public void addWorkspaceIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.WorkspaceId, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.WorkspaceId, "workspaceId");
    }
  }

  public void addServerNameSelectProperty() {
    addServerNameSelectProperty("serverName");
  }

  public void addServerNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.ServerName, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.ServerName, "serverName");
    }
  }

  public void addServerTypeSelectProperty() {
    addServerTypeSelectProperty("serverType");
  }

  public void addServerTypeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.ServerType, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.ServerType, "serverType");
    }
  }

  public void addServerLogoSelectProperty() {
    addServerLogoSelectProperty("serverLogo");
  }

  public void addServerLogoSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.ServerLogo, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.ServerLogo, "serverLogo");
    }
  }

  public void addStartCmdSelectProperty() {
    addStartCmdSelectProperty("startCmd");
  }

  public void addStartCmdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.StartCmd, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.StartCmd, "startCmd");
    }
  }

  public void addStopCmdSelectProperty() {
    addStopCmdSelectProperty("stopCmd");
  }

  public void addStopCmdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.StopCmd, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.StopCmd, "stopCmd");
    }
  }

  public void addRestartCmdSelectProperty() {
    addRestartCmdSelectProperty("restartCmd");
  }

  public void addRestartCmdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.RestartCmd, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.RestartCmd, "restartCmd");
    }
  }

  public void addServerLocationSelectProperty() {
    addServerLocationSelectProperty("serverLocation");
  }

  public void addServerLocationSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.ServerLocation, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.ServerLocation, "serverLocation");
    }
  }

  public void addServerUserSelectProperty() {
    addServerUserSelectProperty("serverUser");
  }

  public void addServerUserSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.ServerUser, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.ServerUser, "serverUser");
    }
  }

  public void addServerPasswordSelectProperty() {
    addServerPasswordSelectProperty("serverPassword");
  }

  public void addServerPasswordSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.ServerPassword, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.ServerPassword, "serverPassword");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.Remarks, "remarks");
    }
  }

  public void addDefaultServerSelectProperty() {
    addDefaultServerSelectProperty("defaultServer");
  }

  public void addDefaultServerSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceServerDAO.DefaultServer, aAlias);
    } else {
      addSelectProperty(IWorkspaceServerDAO.DefaultServer, "defaultServer");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addWorkspaceIdSelectProperty();

    addServerNameSelectProperty();

    addServerTypeSelectProperty();

    addServerLogoSelectProperty();

    addStartCmdSelectProperty();

    addStopCmdSelectProperty();

    addRestartCmdSelectProperty();

    addServerLocationSelectProperty();

    addServerUserSelectProperty();

    addServerPasswordSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addDefaultServerSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceServerDAOQueryBean> {

    protected Criteria(WorkspaceServerDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceServerDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceServerDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.Id + " is not null AND " + IWorkspaceServerDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "(" + IWorkspaceServerDAO.Id + " is null OR " + IWorkspaceServerDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceServerDAO.Id + " is null OR " + IWorkspaceServerDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceServerDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceServerDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceServerDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceServerDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andWorkspaceIdIsNull() {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " is null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotNull() {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " is not null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.WorkspaceId
              + " is not null AND "
              + IWorkspaceServerDAO.WorkspaceId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceServerDAO.WorkspaceId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(long value) {
      return andWorkspaceIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.WorkspaceId + " = ", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.WorkspaceId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(long value) {
      return andWorkspaceIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.WorkspaceId + " <>", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(long value) {
      return andWorkspaceIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceServerDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceServerDAO.WorkspaceId
              + " <>",
          value,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.WorkspaceId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(long value) {
      return andWorkspaceIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.WorkspaceId + " >", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.WorkspaceId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.WorkspaceId + " >=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.WorkspaceId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThan(long value) {
      return andWorkspaceIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.WorkspaceId + " <", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.WorkspaceId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(long value) {
      return andWorkspaceIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceServerDAO.WorkspaceId + " <=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.WorkspaceId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.WorkspaceId + " in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.WorkspaceId + " not in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceServerDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andServerNameIsNull() {
      addCriterion(IWorkspaceServerDAO.ServerName + " is null");
      return this;
    }

    public Criteria andServerNameIsNotNull() {
      addCriterion(IWorkspaceServerDAO.ServerName + " is not null");
      return this;
    }

    public Criteria andServerNameIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.ServerName
              + " is not null AND "
              + IWorkspaceServerDAO.ServerName
              + " <> ''");
      return this;
    }

    public Criteria andServerNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.ServerName
              + " is null OR "
              + IWorkspaceServerDAO.ServerName
              + " = '')");
      return this;
    }

    public Criteria andServerNameEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerName + " = ", value, "serverName");
      return this;
    }

    public Criteria andServerNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerNameEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerName + " <>", value, "serverName");
      return this;
    }

    public Criteria andServerNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.ServerName + " is null OR " + IWorkspaceServerDAO.ServerName + " <>",
          value,
          "serverName");
      return this;
    }

    public Criteria andServerNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerName + " >", value, "serverName");
      return this;
    }

    public Criteria andServerNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerName + " >=", value, "serverName");
      return this;
    }

    public Criteria andServerNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerName + " <", value, "serverName");
      return this;
    }

    public Criteria andServerNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerName + " <=", value, "serverName");
      return this;
    }

    public Criteria andServerNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerName + " like", buffer.toString(), "serverName");
      return this;
    }

    public Criteria andServerNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerName + " not like", buffer.toString(), "serverName");
      return this;
    }

    public Criteria andServerNameIn(List<String> values) {

      if (values.size() == 1) {
        return andServerNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerName + " in", values, "serverName");
        return this;
      }
    }

    public Criteria andServerNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andServerNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerName + " not in", values, "serverName");
        return this;
      }
    }

    public Criteria andServerNameIn(String[] values) {

      if (values.length == 1) {
        return andServerNameEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.ServerName + " in", Arrays.asList(values), "serverName");
        return this;
      }
    }

    public Criteria andServerNameNotIn(String[] values) {
      if (values.length == 1) {
        return andServerNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerName + " not in", Arrays.asList(values), "serverName");
        return this;
      }
    }

    public Criteria andServerNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerName + " between", value1, value2, "serverName");
      return this;
    }

    public Criteria andServerNameNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerName + " not between", value1, value2, "serverName");
      return this;
    }

    public Criteria andServerTypeIsNull() {
      addCriterion(IWorkspaceServerDAO.ServerType + " is null");
      return this;
    }

    public Criteria andServerTypeIsNotNull() {
      addCriterion(IWorkspaceServerDAO.ServerType + " is not null");
      return this;
    }

    public Criteria andServerTypeIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.ServerType
              + " is not null AND "
              + IWorkspaceServerDAO.ServerType
              + " <> ''");
      return this;
    }

    public Criteria andServerTypeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.ServerType
              + " is null OR "
              + IWorkspaceServerDAO.ServerType
              + " = '')");
      return this;
    }

    public Criteria andServerTypeEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerType + " = ", value, "serverType");
      return this;
    }

    public Criteria andServerTypeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerType);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerTypeEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerType + " <>", value, "serverType");
      return this;
    }

    public Criteria andServerTypeNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.ServerType + " is null OR " + IWorkspaceServerDAO.ServerType + " <>",
          value,
          "serverType");
      return this;
    }

    public Criteria andServerTypeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerType);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerTypeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerType + " >", value, "serverType");
      return this;
    }

    public Criteria andServerTypeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerType);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerTypeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerType + " >=", value, "serverType");
      return this;
    }

    public Criteria andServerTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerType);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerTypeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerType + " <", value, "serverType");
      return this;
    }

    public Criteria andServerTypeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerType);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerTypeLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerType + " <=", value, "serverType");
      return this;
    }

    public Criteria andServerTypeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerType);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerTypeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerType + " like", buffer.toString(), "serverType");
      return this;
    }

    public Criteria andServerTypeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerType + " not like", buffer.toString(), "serverType");
      return this;
    }

    public Criteria andServerTypeIn(List<String> values) {

      if (values.size() == 1) {
        return andServerTypeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerType + " in", values, "serverType");
        return this;
      }
    }

    public Criteria andServerTypeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andServerTypeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerType + " not in", values, "serverType");
        return this;
      }
    }

    public Criteria andServerTypeIn(String[] values) {

      if (values.length == 1) {
        return andServerTypeEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.ServerType + " in", Arrays.asList(values), "serverType");
        return this;
      }
    }

    public Criteria andServerTypeNotIn(String[] values) {
      if (values.length == 1) {
        return andServerTypeNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerType + " not in", Arrays.asList(values), "serverType");
        return this;
      }
    }

    public Criteria andServerTypeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerType + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerTypeBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerType + " between", value1, value2, "serverType");
      return this;
    }

    public Criteria andServerTypeNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerType + " not between", value1, value2, "serverType");
      return this;
    }

    public Criteria andServerLogoIsNull() {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " is null");
      return this;
    }

    public Criteria andServerLogoIsNotNull() {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " is not null");
      return this;
    }

    public Criteria andServerLogoIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.ServerLogo
              + " is not null AND "
              + IWorkspaceServerDAO.ServerLogo
              + " <> ''");
      return this;
    }

    public Criteria andServerLogoIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.ServerLogo
              + " is null OR "
              + IWorkspaceServerDAO.ServerLogo
              + " = '')");
      return this;
    }

    public Criteria andServerLogoEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLogo + " = ", value, "serverLogo");
      return this;
    }

    public Criteria andServerLogoEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLogo);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLogoEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLogo + " <>", value, "serverLogo");
      return this;
    }

    public Criteria andServerLogoNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.ServerLogo + " is null OR " + IWorkspaceServerDAO.ServerLogo + " <>",
          value,
          "serverLogo");
      return this;
    }

    public Criteria andServerLogoNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLogo);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLogoNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLogo + " >", value, "serverLogo");
      return this;
    }

    public Criteria andServerLogoGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLogo);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLogoGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLogo + " >=", value, "serverLogo");
      return this;
    }

    public Criteria andServerLogoGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLogo);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLogoGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLogo + " <", value, "serverLogo");
      return this;
    }

    public Criteria andServerLogoLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLogo);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLogoLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLogo + " <=", value, "serverLogo");
      return this;
    }

    public Criteria andServerLogoLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLogo);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLogoLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerLogo + " like", buffer.toString(), "serverLogo");
      return this;
    }

    public Criteria andServerLogoNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerLogo + " not like", buffer.toString(), "serverLogo");
      return this;
    }

    public Criteria andServerLogoIn(List<String> values) {

      if (values.size() == 1) {
        return andServerLogoEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerLogo + " in", values, "serverLogo");
        return this;
      }
    }

    public Criteria andServerLogoNotIn(List<String> values) {
      if (values.size() == 1) {
        return andServerLogoNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerLogo + " not in", values, "serverLogo");
        return this;
      }
    }

    public Criteria andServerLogoIn(String[] values) {

      if (values.length == 1) {
        return andServerLogoEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.ServerLogo + " in", Arrays.asList(values), "serverLogo");
        return this;
      }
    }

    public Criteria andServerLogoNotIn(String[] values) {
      if (values.length == 1) {
        return andServerLogoNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerLogo + " not in", Arrays.asList(values), "serverLogo");
        return this;
      }
    }

    public Criteria andServerLogoIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLogoBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " between", value1, value2, "serverLogo");
      return this;
    }

    public Criteria andServerLogoNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerLogo + " not between", value1, value2, "serverLogo");
      return this;
    }

    public Criteria andStartCmdIsNull() {
      addCriterion(IWorkspaceServerDAO.StartCmd + " is null");
      return this;
    }

    public Criteria andStartCmdIsNotNull() {
      addCriterion(IWorkspaceServerDAO.StartCmd + " is not null");
      return this;
    }

    public Criteria andStartCmdIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.StartCmd
              + " is not null AND "
              + IWorkspaceServerDAO.StartCmd
              + " <> ''");
      return this;
    }

    public Criteria andStartCmdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.StartCmd
              + " is null OR "
              + IWorkspaceServerDAO.StartCmd
              + " = '')");
      return this;
    }

    public Criteria andStartCmdEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StartCmd + " = ", value, "startCmd");
      return this;
    }

    public Criteria andStartCmdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StartCmd);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStartCmdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StartCmd + " <>", value, "startCmd");
      return this;
    }

    public Criteria andStartCmdNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.StartCmd + " is null OR " + IWorkspaceServerDAO.StartCmd + " <>",
          value,
          "startCmd");
      return this;
    }

    public Criteria andStartCmdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StartCmd);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStartCmdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.StartCmd + " >", value, "startCmd");
      return this;
    }

    public Criteria andStartCmdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StartCmd);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStartCmdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StartCmd + " >=", value, "startCmd");
      return this;
    }

    public Criteria andStartCmdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StartCmd);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStartCmdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.StartCmd + " <", value, "startCmd");
      return this;
    }

    public Criteria andStartCmdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StartCmd);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStartCmdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StartCmd + " <=", value, "startCmd");
      return this;
    }

    public Criteria andStartCmdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StartCmd);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStartCmdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.StartCmd + " like", buffer.toString(), "startCmd");
      return this;
    }

    public Criteria andStartCmdNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.StartCmd + " not like", buffer.toString(), "startCmd");
      return this;
    }

    public Criteria andStartCmdIn(List<String> values) {

      if (values.size() == 1) {
        return andStartCmdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.StartCmd + " in", values, "startCmd");
        return this;
      }
    }

    public Criteria andStartCmdNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStartCmdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.StartCmd + " not in", values, "startCmd");
        return this;
      }
    }

    public Criteria andStartCmdIn(String[] values) {

      if (values.length == 1) {
        return andStartCmdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.StartCmd + " in", Arrays.asList(values), "startCmd");
        return this;
      }
    }

    public Criteria andStartCmdNotIn(String[] values) {
      if (values.length == 1) {
        return andStartCmdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.StartCmd + " not in", Arrays.asList(values), "startCmd");
        return this;
      }
    }

    public Criteria andStartCmdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStartCmdBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " between", value1, value2, "startCmd");
      return this;
    }

    public Criteria andStartCmdNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.StartCmd + " not between", value1, value2, "startCmd");
      return this;
    }

    public Criteria andStopCmdIsNull() {
      addCriterion(IWorkspaceServerDAO.StopCmd + " is null");
      return this;
    }

    public Criteria andStopCmdIsNotNull() {
      addCriterion(IWorkspaceServerDAO.StopCmd + " is not null");
      return this;
    }

    public Criteria andStopCmdIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.StopCmd
              + " is not null AND "
              + IWorkspaceServerDAO.StopCmd
              + " <> ''");
      return this;
    }

    public Criteria andStopCmdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.StopCmd
              + " is null OR "
              + IWorkspaceServerDAO.StopCmd
              + " = '')");
      return this;
    }

    public Criteria andStopCmdEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StopCmd + " = ", value, "stopCmd");
      return this;
    }

    public Criteria andStopCmdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StopCmd);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStopCmdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StopCmd + " <>", value, "stopCmd");
      return this;
    }

    public Criteria andStopCmdNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.StopCmd + " is null OR " + IWorkspaceServerDAO.StopCmd + " <>",
          value,
          "stopCmd");
      return this;
    }

    public Criteria andStopCmdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StopCmd);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStopCmdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.StopCmd + " >", value, "stopCmd");
      return this;
    }

    public Criteria andStopCmdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StopCmd);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStopCmdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StopCmd + " >=", value, "stopCmd");
      return this;
    }

    public Criteria andStopCmdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StopCmd);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStopCmdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.StopCmd + " <", value, "stopCmd");
      return this;
    }

    public Criteria andStopCmdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StopCmd);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStopCmdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.StopCmd + " <=", value, "stopCmd");
      return this;
    }

    public Criteria andStopCmdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.StopCmd);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStopCmdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.StopCmd + " like", buffer.toString(), "stopCmd");
      return this;
    }

    public Criteria andStopCmdNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.StopCmd + " not like", buffer.toString(), "stopCmd");
      return this;
    }

    public Criteria andStopCmdIn(List<String> values) {

      if (values.size() == 1) {
        return andStopCmdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.StopCmd + " in", values, "stopCmd");
        return this;
      }
    }

    public Criteria andStopCmdNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStopCmdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.StopCmd + " not in", values, "stopCmd");
        return this;
      }
    }

    public Criteria andStopCmdIn(String[] values) {

      if (values.length == 1) {
        return andStopCmdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.StopCmd + " in", Arrays.asList(values), "stopCmd");
        return this;
      }
    }

    public Criteria andStopCmdNotIn(String[] values) {
      if (values.length == 1) {
        return andStopCmdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.StopCmd + " not in", Arrays.asList(values), "stopCmd");
        return this;
      }
    }

    public Criteria andStopCmdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStopCmdBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " between", value1, value2, "stopCmd");
      return this;
    }

    public Criteria andStopCmdNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.StopCmd + " not between", value1, value2, "stopCmd");
      return this;
    }

    public Criteria andRestartCmdIsNull() {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " is null");
      return this;
    }

    public Criteria andRestartCmdIsNotNull() {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " is not null");
      return this;
    }

    public Criteria andRestartCmdIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.RestartCmd
              + " is not null AND "
              + IWorkspaceServerDAO.RestartCmd
              + " <> ''");
      return this;
    }

    public Criteria andRestartCmdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.RestartCmd
              + " is null OR "
              + IWorkspaceServerDAO.RestartCmd
              + " = '')");
      return this;
    }

    public Criteria andRestartCmdEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.RestartCmd + " = ", value, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.RestartCmd);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRestartCmdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.RestartCmd + " <>", value, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.RestartCmd + " is null OR " + IWorkspaceServerDAO.RestartCmd + " <>",
          value,
          "restartCmd");
      return this;
    }

    public Criteria andRestartCmdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.RestartCmd);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRestartCmdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.RestartCmd + " >", value, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.RestartCmd);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRestartCmdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.RestartCmd + " >=", value, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.RestartCmd);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRestartCmdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.RestartCmd + " <", value, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.RestartCmd);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRestartCmdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.RestartCmd + " <=", value, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.RestartCmd);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRestartCmdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.RestartCmd + " like", buffer.toString(), "restartCmd");
      return this;
    }

    public Criteria andRestartCmdNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.RestartCmd + " not like", buffer.toString(), "restartCmd");
      return this;
    }

    public Criteria andRestartCmdIn(List<String> values) {

      if (values.size() == 1) {
        return andRestartCmdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.RestartCmd + " in", values, "restartCmd");
        return this;
      }
    }

    public Criteria andRestartCmdNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRestartCmdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.RestartCmd + " not in", values, "restartCmd");
        return this;
      }
    }

    public Criteria andRestartCmdIn(String[] values) {

      if (values.length == 1) {
        return andRestartCmdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.RestartCmd + " in", Arrays.asList(values), "restartCmd");
        return this;
      }
    }

    public Criteria andRestartCmdNotIn(String[] values) {
      if (values.length == 1) {
        return andRestartCmdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.RestartCmd + " not in", Arrays.asList(values), "restartCmd");
        return this;
      }
    }

    public Criteria andRestartCmdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRestartCmdBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " between", value1, value2, "restartCmd");
      return this;
    }

    public Criteria andRestartCmdNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.RestartCmd + " not between", value1, value2, "restartCmd");
      return this;
    }

    public Criteria andServerLocationIsNull() {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " is null");
      return this;
    }

    public Criteria andServerLocationIsNotNull() {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " is not null");
      return this;
    }

    public Criteria andServerLocationIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.ServerLocation
              + " is not null AND "
              + IWorkspaceServerDAO.ServerLocation
              + " <> ''");
      return this;
    }

    public Criteria andServerLocationIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.ServerLocation
              + " is null OR "
              + IWorkspaceServerDAO.ServerLocation
              + " = '')");
      return this;
    }

    public Criteria andServerLocationEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLocation + " = ", value, "serverLocation");
      return this;
    }

    public Criteria andServerLocationEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLocation);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLocationEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLocation + " <>", value, "serverLocation");
      return this;
    }

    public Criteria andServerLocationNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.ServerLocation
              + " is null OR "
              + IWorkspaceServerDAO.ServerLocation
              + " <>",
          value,
          "serverLocation");
      return this;
    }

    public Criteria andServerLocationNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLocation);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLocationNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLocation + " >", value, "serverLocation");
      return this;
    }

    public Criteria andServerLocationGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLocation);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLocationGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLocation + " >=", value, "serverLocation");
      return this;
    }

    public Criteria andServerLocationGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLocation);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLocationGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLocation + " <", value, "serverLocation");
      return this;
    }

    public Criteria andServerLocationLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLocation);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLocationLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerLocation + " <=", value, "serverLocation");
      return this;
    }

    public Criteria andServerLocationLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerLocation);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerLocationLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceServerDAO.ServerLocation + " like", buffer.toString(), "serverLocation");
      return this;
    }

    public Criteria andServerLocationNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceServerDAO.ServerLocation + " not like", buffer.toString(), "serverLocation");
      return this;
    }

    public Criteria andServerLocationIn(List<String> values) {

      if (values.size() == 1) {
        return andServerLocationEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerLocation + " in", values, "serverLocation");
        return this;
      }
    }

    public Criteria andServerLocationNotIn(List<String> values) {
      if (values.size() == 1) {
        return andServerLocationNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerLocation + " not in", values, "serverLocation");
        return this;
      }
    }

    public Criteria andServerLocationIn(String[] values) {

      if (values.length == 1) {
        return andServerLocationEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerLocation + " in", Arrays.asList(values), "serverLocation");
        return this;
      }
    }

    public Criteria andServerLocationNotIn(String[] values) {
      if (values.length == 1) {
        return andServerLocationNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerLocation + " not in",
            Arrays.asList(values),
            "serverLocation");
        return this;
      }
    }

    public Criteria andServerLocationIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerLocation + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerLocationBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceServerDAO.ServerLocation + " between", value1, value2, "serverLocation");
      return this;
    }

    public Criteria andServerLocationNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceServerDAO.ServerLocation + " not between", value1, value2, "serverLocation");
      return this;
    }

    public Criteria andServerUserIsNull() {
      addCriterion(IWorkspaceServerDAO.ServerUser + " is null");
      return this;
    }

    public Criteria andServerUserIsNotNull() {
      addCriterion(IWorkspaceServerDAO.ServerUser + " is not null");
      return this;
    }

    public Criteria andServerUserIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.ServerUser
              + " is not null AND "
              + IWorkspaceServerDAO.ServerUser
              + " <> ''");
      return this;
    }

    public Criteria andServerUserIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.ServerUser
              + " is null OR "
              + IWorkspaceServerDAO.ServerUser
              + " = '')");
      return this;
    }

    public Criteria andServerUserEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerUser + " = ", value, "serverUser");
      return this;
    }

    public Criteria andServerUserEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerUser);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerUserEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerUser + " <>", value, "serverUser");
      return this;
    }

    public Criteria andServerUserNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.ServerUser + " is null OR " + IWorkspaceServerDAO.ServerUser + " <>",
          value,
          "serverUser");
      return this;
    }

    public Criteria andServerUserNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerUser);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerUserNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerUser + " >", value, "serverUser");
      return this;
    }

    public Criteria andServerUserGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerUser);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerUserGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerUser + " >=", value, "serverUser");
      return this;
    }

    public Criteria andServerUserGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerUser);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerUserGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerUser + " <", value, "serverUser");
      return this;
    }

    public Criteria andServerUserLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerUser);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerUserLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerUser + " <=", value, "serverUser");
      return this;
    }

    public Criteria andServerUserLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerUser);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerUserLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerUser + " like", buffer.toString(), "serverUser");
      return this;
    }

    public Criteria andServerUserNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.ServerUser + " not like", buffer.toString(), "serverUser");
      return this;
    }

    public Criteria andServerUserIn(List<String> values) {

      if (values.size() == 1) {
        return andServerUserEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerUser + " in", values, "serverUser");
        return this;
      }
    }

    public Criteria andServerUserNotIn(List<String> values) {
      if (values.size() == 1) {
        return andServerUserNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerUser + " not in", values, "serverUser");
        return this;
      }
    }

    public Criteria andServerUserIn(String[] values) {

      if (values.length == 1) {
        return andServerUserEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.ServerUser + " in", Arrays.asList(values), "serverUser");
        return this;
      }
    }

    public Criteria andServerUserNotIn(String[] values) {
      if (values.length == 1) {
        return andServerUserNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerUser + " not in", Arrays.asList(values), "serverUser");
        return this;
      }
    }

    public Criteria andServerUserIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerUserBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " between", value1, value2, "serverUser");
      return this;
    }

    public Criteria andServerUserNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.ServerUser + " not between", value1, value2, "serverUser");
      return this;
    }

    public Criteria andServerPasswordIsNull() {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " is null");
      return this;
    }

    public Criteria andServerPasswordIsNotNull() {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " is not null");
      return this;
    }

    public Criteria andServerPasswordIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.ServerPassword
              + " is not null AND "
              + IWorkspaceServerDAO.ServerPassword
              + " <> ''");
      return this;
    }

    public Criteria andServerPasswordIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.ServerPassword
              + " is null OR "
              + IWorkspaceServerDAO.ServerPassword
              + " = '')");
      return this;
    }

    public Criteria andServerPasswordEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerPassword + " = ", value, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerPassword);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerPasswordEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerPassword + " <>", value, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.ServerPassword
              + " is null OR "
              + IWorkspaceServerDAO.ServerPassword
              + " <>",
          value,
          "serverPassword");
      return this;
    }

    public Criteria andServerPasswordNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerPassword);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerPasswordNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerPassword + " >", value, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerPassword);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerPasswordGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerPassword + " >=", value, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerPassword);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerPasswordGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.ServerPassword + " <", value, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerPassword);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerPasswordLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.ServerPassword + " <=", value, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.ServerPassword);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andServerPasswordLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceServerDAO.ServerPassword + " like", buffer.toString(), "serverPassword");
      return this;
    }

    public Criteria andServerPasswordNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceServerDAO.ServerPassword + " not like", buffer.toString(), "serverPassword");
      return this;
    }

    public Criteria andServerPasswordIn(List<String> values) {

      if (values.size() == 1) {
        return andServerPasswordEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerPassword + " in", values, "serverPassword");
        return this;
      }
    }

    public Criteria andServerPasswordNotIn(List<String> values) {
      if (values.size() == 1) {
        return andServerPasswordNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.ServerPassword + " not in", values, "serverPassword");
        return this;
      }
    }

    public Criteria andServerPasswordIn(String[] values) {

      if (values.length == 1) {
        return andServerPasswordEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerPassword + " in", Arrays.asList(values), "serverPassword");
        return this;
      }
    }

    public Criteria andServerPasswordNotIn(String[] values) {
      if (values.length == 1) {
        return andServerPasswordNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.ServerPassword + " not in",
            Arrays.asList(values),
            "serverPassword");
        return this;
      }
    }

    public Criteria andServerPasswordIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.ServerPassword + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andServerPasswordBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceServerDAO.ServerPassword + " between", value1, value2, "serverPassword");
      return this;
    }

    public Criteria andServerPasswordNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceServerDAO.ServerPassword + " not between", value1, value2, "serverPassword");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceServerDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceServerDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.Status + " is not null AND " + IWorkspaceServerDAO.Status + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.Status
              + " is null OR "
              + IWorkspaceServerDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.Status + " is null OR " + IWorkspaceServerDAO.Status + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IWorkspaceServerDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IWorkspaceServerDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.Remarks
              + " is not null AND "
              + IWorkspaceServerDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.Remarks
              + " is null OR "
              + IWorkspaceServerDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.Remarks + " is null OR " + IWorkspaceServerDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceServerDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andDefaultServerIsNull() {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " is null");
      return this;
    }

    public Criteria andDefaultServerIsNotNull() {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " is not null");
      return this;
    }

    public Criteria andDefaultServerIsNotEmpty() {
      addCriterion(
          IWorkspaceServerDAO.DefaultServer
              + " is not null AND "
              + IWorkspaceServerDAO.DefaultServer
              + " <> ''");
      return this;
    }

    public Criteria andDefaultServerIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceServerDAO.DefaultServer
              + " is null OR "
              + IWorkspaceServerDAO.DefaultServer
              + " = '')");
      return this;
    }

    public Criteria andDefaultServerEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.DefaultServer + " = ", value, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.DefaultServer);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultServerEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerNotEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.DefaultServer + " <>", value, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceServerDAO.DefaultServer
              + " is null OR "
              + IWorkspaceServerDAO.DefaultServer
              + " <>",
          value,
          "defaultServer");
      return this;
    }

    public Criteria andDefaultServerNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.DefaultServer);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultServerNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerGreaterThan(String value) {

      addCriterion(IWorkspaceServerDAO.DefaultServer + " >", value, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.DefaultServer);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultServerGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.DefaultServer + " >=", value, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.DefaultServer);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultServerGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerLessThan(String value) {

      addCriterion(IWorkspaceServerDAO.DefaultServer + " <", value, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.DefaultServer);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultServerLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceServerDAO.DefaultServer + " <=", value, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceServerDAO.DefaultServer);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andDefaultServerLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceServerDAO.DefaultServer + " like", buffer.toString(), "defaultServer");
      return this;
    }

    public Criteria andDefaultServerNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceServerDAO.DefaultServer + " not like", buffer.toString(), "defaultServer");
      return this;
    }

    public Criteria andDefaultServerIn(List<String> values) {

      if (values.size() == 1) {
        return andDefaultServerEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.DefaultServer + " in", values, "defaultServer");
        return this;
      }
    }

    public Criteria andDefaultServerNotIn(List<String> values) {
      if (values.size() == 1) {
        return andDefaultServerNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceServerDAO.DefaultServer + " not in", values, "defaultServer");
        return this;
      }
    }

    public Criteria andDefaultServerIn(String[] values) {

      if (values.length == 1) {
        return andDefaultServerEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.DefaultServer + " in", Arrays.asList(values), "defaultServer");
        return this;
      }
    }

    public Criteria andDefaultServerNotIn(String[] values) {
      if (values.length == 1) {
        return andDefaultServerNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceServerDAO.DefaultServer + " not in", Arrays.asList(values), "defaultServer");
        return this;
      }
    }

    public Criteria andDefaultServerIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andDefaultServerBetween(String value1, String value2) {
      addCriterion(IWorkspaceServerDAO.DefaultServer + " between", value1, value2, "defaultServer");
      return this;
    }

    public Criteria andDefaultServerNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceServerDAO.DefaultServer + " not between", value1, value2, "defaultServer");
      return this;
    }
  }
}
